package com.glls.lambda.demo1;

import com.glls.lambda.pojo.Student;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.TreeSet;

/**
 * @date 2022/10/3
 * @desc
 *
 * 初识 lambda 表达式
 * lambda表达式的本质可以理解为接口的实例（或者准确点说 是 接口的实现类的实例）
 * lambda 表达式 是依赖于接口而存在的  这个接口是一个函数式接口
 */
public class LambdaDemo1 {

    @Test
    public void testCollection(){
        TreeSet<Object> treeSet = new TreeSet<>();
        //treeSet.add("javase");
        //treeSet.add("spring");
        //treeSet.add("springmvc");
        Student student = new Student(1, "zs", 18, 88.0);
        // TreeSet 是一个有序的集合  往里面添加元素  要么元素自身可以排序   要么  告诉TreeSet 排序规则
        //treeSet.add(student);   // ？？？

    }



    List<Student> list = Arrays.asList(
            new Student(1,"zs",18,88.0),
            new Student(2,"ls",19,88.5),
            new Student(3,"ww",21,98.0),
            new Student(4,"zl",19,86.0),
            new Student(5,"tq",17,92.0)
    );

    @Test
    public void test(){
        //需求1   得到90分以上的学员信息
        //filterStudentsByScore();
        //需求2   得到年龄20以上的学员信息
        //filterStudentsByAge();

        //开始优化
        //成绩90以上
        //FilterRule filterRule = new ScoreFilterRule();
        //年龄20以上
        //FilterRule filterRule = new AgeFilterRule();
        //filterStudentsByRule(list,filterRule);

        //继续优化
        //使用匿名内部类
        //filterStudentsByRule(list, new FilterRule<Student>() {
        //
        //    @Override
        //    public boolean filter(Student student) {
        //        return student.getScore()>90;
        //    }
        //});

        //继续优化  引入 lambda 表达式了
        filterStudentsByRule(list,(s)->{return s.getScore()>90;});
        //List<Student> students = filterStudentsByRule(list, s -> s.getAge() > 20);
        // 之前的遍历方式
        //for (int i = 0; i < students.size(); i++) {
        //    System.out.println(students.get(i));
        //}

        //students.forEach(System.out::println);

        // 最后的优化
        //得到90以上的学员信息
        //list.stream().filter(s->s.getScore()>90).forEach(System.out::println);
        //得到年龄20岁以上的学员名字
        list.stream().filter(s->s.getAge()>20).map(Student::getName).forEach(System.out::println);

        //使用了lambda  表达式以后 代码看起来简洁了  但是 并没有提高程序的性能 它是一个语法糖
    }

    private List<Student> filterStudentsByRule(List<Student> list, FilterRule<Student> filterRule) {
        ArrayList<Student> students = new ArrayList<>();
        for(int i=0;i<list.size();i++){
            if(filterRule.filter(list.get(i))){
                students.add(list.get(i));
            }
        }
        //System.out.println(students);

        return students;
    }

    private void filterStudentsByAge() {
        ArrayList<Student> students = new ArrayList<>();
        for(int i=0;i<list.size();i++){
            if(list.get(i).getAge()>20){
                students.add(list.get(i));
            }
        }
        System.out.println(students);
    }

    private void filterStudentsByScore() {
        ArrayList<Student> students = new ArrayList<>();
        for(int i=0;i<list.size();i++){
            if(list.get(i).getScore()>90){
                students.add(list.get(i));
            }
        }
        System.out.println(students);
    }
}
